package com.zatech.cgnci.project.base.utils;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Bean转换类.
 *
 */
@Slf4j
public class ConvertUtils {



    /**
     * 将Object对象里面的属性和值转化成Map对象
     *
     * @param obj
     * @return
     * @throws IllegalAccessException
     */
//    public static Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
//        Map<String, Object> map = new HashMap<String,Object>();
//        Class<?> clazz = obj.getClass();
//        for (Field field : clazz.getDeclaredFields()) {
//            field.setAccessible(true);
//            String fieldName = field.getName();
//            Object value = field.get(obj);
//            map.put(fieldName, value);
//        }
//        return map;
//    }

    /**
     * 转换指定泛型A->B.
     *
     * @param source      源对象
     * @param targetClass 转换对象的Class，不能为null，必须要有无参构造器，权限必须能被此工具类访问
     * @return 转化后的对象
     */
    public static <T> T convert(Object source, Class<T> targetClass) {
        if (source == null) {
            return null;
        }
        try {
            T obj = targetClass.newInstance();
            BeanUtils.copyProperties(source, obj);
            return obj;
        } catch (InstantiationException | IllegalAccessException e) {
            log.error("{}没有无参构造器或无权限访问", targetClass.getSimpleName());
            throw new RuntimeException("没有无参构造器或无权限访问");
        }
    }

    /**
     * 转换集合.
     *
     * @param sourceList  源集合
     * @param targetClass 目标类
     * @param <F>         转换前类型
     * @param <T>         转换后的类型
     * @return List<T> 转换后的集合
     */
    public static <F, T> List<T> convert(List<F> sourceList, Class<T> targetClass) {

        if (CollectionUtils.isEmpty(sourceList)) {
            return Collections.emptyList();
        }

        return sourceList.stream().map(item -> convert(item, targetClass)).collect(Collectors.toList());
    }

    /**
     * 转换集合.
     *
     * @param sourceList  源集合
     * @param targetClass 目标类
     * @param <F>         转换前类型
     * @param <T>         转换后的类型
     * @return List<T> 转换后的集合
     */
    public static <F, T> Set<T> convert(Set<F> sourceList, Class<T> targetClass) {

        if (CollectionUtils.isEmpty(sourceList)) {
            return Collections.emptySet();
        }

        return sourceList.stream().map(item -> convert(item, targetClass)).collect(Collectors.toSet());
    }


    /**
     * 转换IPage
     *
     * @param iPage       源page接口
     * @param targetClass 目标类
     * @param <F>         转换前类型
     * @param <T>         转换后的类型
     * @return Page<T> 分页数据
     */
    public static <F, T> Page<T> covertPage(IPage<F> iPage, Class<T> targetClass) {
        return (Page<T>) iPage.convert(e -> ConvertUtils.convert(e, targetClass));
    }


}
